The present invention relates to an apparatus and method for locating and displaying identification of objects within a computer-implemented object environment.
Object-oriented programming (OOP) is a process of developing computer software using objects, including the steps of analyzing the problem, designing the system, and constructing the program. An object is a software package that contains both data and a collection of related procedures. Since it contains both data and procedures, it can be visualized as a self-sufficient component that does not require other additional procedures or data to perform its specific task. OOP, therefore, views a computer program as a collection of largely autonomous components, called objects, each of which is responsible for a specific task. This concept of packaging data and procedures together in one component or module is called encapsulation.
Components, in general, are reusable software modules which present an interface that conforms to an object model and which are accessed at run-time through a component integration architecture. A component integration architecture is a set of architecture mechanisms which allow software modules in different process spaces to utilize each other""s capabilities or functions. This is generally done by assuming a common component object model on which to build the architecture.
It is worthwhile to differentiate between an object and a class of objects. An object is a single instance of the class of objects, which is often just called a class. A class of objects can be viewed as a blueprint, from which many objects can be formed. In the following discussion, the term object refers to a class of objects and all possible objects that can be formed from the class.
OOP allows the programmer to create an object that is a part of another object. For example, the object representing a piston engine is said to have a composition-relationship with the object representing a piston. In reality, a piston engine comprises a piston, valves and many other components; the fact that a piston is an element of a piston engine can be logically and semantically represented in OOP by two objects.
OOP also allows creation of an object that xe2x80x9cdepends fromxe2x80x9d another object. If there are two objects, one representing a piston engine and the other representing a piston engine wherein the piston is made of ceramic, then the relationship between the two objects is not that of composition. A ceramic piston engine does not make up a piston engine. Rather it is merely one kind of piston engine that has one more limitation than the piston engine; its piston is made of ceramic. In this case, the object representing the ceramic piston engine is called a derived object; it inherits all the aspects of the object representing the piston engine and adds further limitation or detail to it. The object representing the ceramic piston engine xe2x80x9cdepends fromxe2x80x9d the object representing the piston engine. The relationship between these objects is called inheritance.
With the concepts of composition-relationship, inheritance and encapsulation, an object can represent just about anything in the real world. In fact, a person""s logical perception of reality is the only limit on determining the kinds of things that can become objects in object-oriented software. Some typical categories are as follows: Objects can represent physical objects, such as automobiles in a traffic-flow simulation, electrical components in a circuit-design program, countries in an economics model, or aircraft in an air-traffic-control system. Objects can represent elements of the computer-user environment such as windows, menus or graphics objects. An object can represent an inventory, such as a personnel file or a table of the latitudes and longitudes of cities. An object can represent user-defined data types such as time, angles, and complex numbers, or point on the plane.
With this enormous capability of the object to represent just about any logically separable matters, OOP allows the software developer to design and implement a computer program that is a model of some aspects of reality, whether that reality is a physical entity or a process. Since the object can represent anything, the software developer can create an object which can be used as a component in a larger software project in the future.
If 90% of a new software consists of proven, existing components made from the preexisting reusable objects, then only the remaining 10% of the new software project has to be written and tested from scratch. Since 90% already came from an inventory of extensively tested reusable objects, the potential domain from which an error could originate is 10% of the program. As a result, OOP enables the software developers to build objects out of other objects, which in turn may have been built out of earlier objects.
This process closely resembles complex machinery being built out of assemblies and sub-assemblies. OOP technology, therefore, makes software engineering more like hardware engineering in that software is built from existing components, which are available to the developer as objects. All this adds up to an improved quality of the software as well as an increased-speed of its development.
In order for OOP to truly flourish, programming languages must fully support the OOP principles, such as encapsulation, inheritance and composition-relationship. With the advent of the C++ programming language, many commercial software developers have embraced QOP. C++ is an OOP language that offers a fast, machine-executable code, and that is suitable for both commercial-application and systems-programming projects. For now, C++ appears to be the most popular choice among many programmers, but there is a host of other OOP languages, such as the SMALLTALK, COMMON LISP OBJECT SYSTEM (CLOS), and EIFFEL programming languages. Additionally, the OOP capabilities are being added on to the existing popular computer programming languages such as the PASCAL programming language.
In addition, for OOP to be truly effective in the future, all reusable objects must be readily accessible to interested parties. This will require an object-oriented database, which may consist of a collection of smaller databases. At minimum, such database should be based on an intelligent classification system and should support search methods that allow an interested party to search and access the database using the open standard, which is necessary to accommodate software developers using different OOP languages and different interfaces.
Ideally, this database will allow an interested party to search and access an object, a class of objects, a class library of objects and a framework of class libraries of objects. In this scheme, an object will be the smallest unit of search. A class of objects can be viewed as a template of such an object, similar to a blueprint, from which many instances of classes are logically related to each other in order to perform a complicated task that a single object or a single class cannot perform. A framework of class libraries is even more complex. It will consist of significant collections of collaborating classes that capture both the small scale patterns and major mechanisms that implement the common requirements and design in a specific application domain.
Further, OOP principles ideally should be extended such that individual developers can modify the operations of shared components at run-time without changing the software code of the components themselves. This will allow larger and more complex shared components to be developed and individually tailored to a particular customer""s needs by the software developer. At the same time, this will minimize the need to develop specialized components for each individual customer that provide substantially the same functions. For example, a single component having spell checking functions can be developed and individually tailored for use in a word processor, presentations package, accounting system, point of sale system, or the like. Significantly, such a component need only be developed and debugged one time.
Objects also have one or more properties. A collection of objects may therefore have many different properties. These properties can be displayed on a computer screen. However, it can be difficult for a user to locate and view a particular property among these objects. This is particularly true when many objects are displayed in several levels or groups, such that a user would typically be required to search through the levels and multiple objects in order to locate a particular property.
This invention is a system and method for navigating at least one object within a computer-implemented object environment. The system electronically specifies at least one object having particular attributes. An object environment is displayed, including representations of the object and the corresponding particular attributes. Upon selection by a user, the system provides a visual indication of a location of a user-specified attribute within the displayed object environment.